home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / SLAX 6.0.8 / slax-6.0.8.iso / slax / base / 006-devel.lzm / usr / share / aclocal / lock.m4 < prev    next >
Encoding:
M4 Source File  |  2008-03-13  |  12.1 KB  |  317 lines
  1. # lock.m4 serial 7 (gettext-0.17)
  2. dnl Copyright (C) 2005-2007 Free Software Foundation, Inc.
  3. dnl This file is free software; the Free Software Foundation
  4. dnl gives unlimited permission to copy and/or distribute it,
  5. dnl with or without modifications, as long as this notice is preserved.
  6.  
  7. dnl From Bruno Haible.
  8.  
  9. dnl Tests for a multithreading library to be used.
  10. dnl Defines at most one of the macros USE_POSIX_THREADS, USE_SOLARIS_THREADS,
  11. dnl USE_PTH_THREADS, USE_WIN32_THREADS
  12. dnl Sets the variables LIBTHREAD and LTLIBTHREAD to the linker options for use
  13. dnl in a Makefile (LIBTHREAD for use without libtool, LTLIBTHREAD for use with
  14. dnl libtool).
  15. dnl Sets the variables LIBMULTITHREAD and LTLIBMULTITHREAD similarly, for
  16. dnl programs that really need multithread functionality. The difference
  17. dnl between LIBTHREAD and LIBMULTITHREAD is that on platforms supporting weak
  18. dnl symbols, typically LIBTHREAD="" whereas LIBMULTITHREAD="-lpthread".
  19. dnl Adds to CPPFLAGS the flag -D_REENTRANT or -D_THREAD_SAFE if needed for
  20. dnl multithread-safe programs.
  21.  
  22. AC_DEFUN([gl_LOCK_EARLY],
  23. [
  24.   AC_REQUIRE([gl_LOCK_EARLY_BODY])
  25. ])
  26.  
  27. dnl The guts of gl_LOCK_EARLY. Needs to be expanded only once.
  28.  
  29. AC_DEFUN([gl_LOCK_EARLY_BODY],
  30. [
  31.   dnl Ordering constraints: This macro modifies CPPFLAGS in a way that
  32.   dnl influences the result of the autoconf tests that test for *_unlocked
  33.   dnl declarations, on AIX 5 at least. Therefore it must come early.
  34.   AC_BEFORE([$0], [gl_FUNC_GLIBC_UNLOCKED_IO])dnl
  35.   AC_BEFORE([$0], [gl_ARGP])dnl
  36.  
  37.   AC_REQUIRE([AC_CANONICAL_HOST])
  38.   dnl _GNU_SOURCE is needed for pthread_rwlock_t on glibc systems.
  39.   dnl AC_USE_SYSTEM_EXTENSIONS was introduced in autoconf 2.60 and obsoletes
  40.   dnl AC_GNU_SOURCE.
  41.   m4_ifdef([AC_USE_SYSTEM_EXTENSIONS],
  42.     [AC_REQUIRE([AC_USE_SYSTEM_EXTENSIONS])],
  43.     [AC_REQUIRE([AC_GNU_SOURCE])])
  44.   dnl Check for multithreading.
  45.   AC_ARG_ENABLE(threads,
  46. AC_HELP_STRING([--enable-threads={posix|solaris|pth|win32}], [specify multithreading API])
  47. AC_HELP_STRING([--disable-threads], [build without multithread safety]),
  48.     [gl_use_threads=$enableval],
  49.     [case "$host_os" in
  50.        dnl Disable multithreading by default on OSF/1, because it interferes
  51.        dnl with fork()/exec(): When msgexec is linked with -lpthread, its child
  52.        dnl process gets an endless segmentation fault inside execvp().
  53.        osf*) gl_use_threads=no ;;
  54.        *)    gl_use_threads=yes ;;
  55.      esac
  56.     ])
  57.   if test "$gl_use_threads" = yes || test "$gl_use_threads" = posix; then
  58.     # For using <pthread.h>:
  59.     case "$host_os" in
  60.       osf*)
  61.         # On OSF/1, the compiler needs the flag -D_REENTRANT so that it
  62.         # groks <pthread.h>. cc also understands the flag -pthread, but
  63.         # we don't use it because 1. gcc-2.95 doesn't understand -pthread,
  64.         # 2. putting a flag into CPPFLAGS that has an effect on the linker
  65.         # causes the AC_TRY_LINK test below to succeed unexpectedly,
  66.         # leading to wrong values of LIBTHREAD and LTLIBTHREAD.
  67.         CPPFLAGS="$CPPFLAGS -D_REENTRANT"
  68.         ;;
  69.     esac
  70.     # Some systems optimize for single-threaded programs by default, and
  71.     # need special flags to disable these optimizations. For example, the
  72.     # definition of 'errno' in <errno.h>.
  73.     case "$host_os" in
  74.       aix* | freebsd*) CPPFLAGS="$CPPFLAGS -D_THREAD_SAFE" ;;
  75.       solaris*) CPPFLAGS="$CPPFLAGS -D_REENTRANT" ;;
  76.     esac
  77.   fi
  78. ])
  79.  
  80. dnl The guts of gl_LOCK. Needs to be expanded only once.
  81.  
  82. AC_DEFUN([gl_LOCK_BODY],
  83. [
  84.   AC_REQUIRE([gl_LOCK_EARLY_BODY])
  85.   gl_threads_api=none
  86.   LIBTHREAD=
  87.   LTLIBTHREAD=
  88.   LIBMULTITHREAD=
  89.   LTLIBMULTITHREAD=
  90.   if test "$gl_use_threads" != no; then
  91.     dnl Check whether the compiler and linker support weak declarations.
  92.     AC_MSG_CHECKING([whether imported symbols can be declared weak])
  93.     gl_have_weak=no
  94.     AC_TRY_LINK([extern void xyzzy ();
  95. #pragma weak xyzzy], [xyzzy();], [gl_have_weak=yes])
  96.     AC_MSG_RESULT([$gl_have_weak])
  97.     if test "$gl_use_threads" = yes || test "$gl_use_threads" = posix; then
  98.       # On OSF/1, the compiler needs the flag -pthread or -D_REENTRANT so that
  99.       # it groks <pthread.h>. It's added above, in gl_LOCK_EARLY_BODY.
  100.       AC_CHECK_HEADER(pthread.h, gl_have_pthread_h=yes, gl_have_pthread_h=no)
  101.       if test "$gl_have_pthread_h" = yes; then
  102.         # Other possible tests:
  103.         #   -lpthreads (FSU threads, PCthreads)
  104.         #   -lgthreads
  105.         gl_have_pthread=
  106.         # Test whether both pthread_mutex_lock and pthread_mutexattr_init exist
  107.         # in libc. IRIX 6.5 has the first one in both libc and libpthread, but
  108.         # the second one only in libpthread, and lock.c needs it.
  109.         AC_TRY_LINK([#include <pthread.h>],
  110.           [pthread_mutex_lock((pthread_mutex_t*)0);
  111.            pthread_mutexattr_init((pthread_mutexattr_t*)0);],
  112.           [gl_have_pthread=yes])
  113.         # Test for libpthread by looking for pthread_kill. (Not pthread_self,
  114.         # since it is defined as a macro on OSF/1.)
  115.         if test -n "$gl_have_pthread"; then
  116.           # The program links fine without libpthread. But it may actually
  117.           # need to link with libpthread in order to create multiple threads.
  118.           AC_CHECK_LIB(pthread, pthread_kill,
  119.             [LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread
  120.              # On Solaris and HP-UX, most pthread functions exist also in libc.
  121.              # Therefore pthread_in_use() needs to actually try to create a
  122.              # thread: pthread_create from libc will fail, whereas
  123.              # pthread_create will actually create a thread.
  124.              case "$host_os" in
  125.                solaris* | hpux*)
  126.                  AC_DEFINE([PTHREAD_IN_USE_DETECTION_HARD], 1,
  127.                    [Define if the pthread_in_use() detection is hard.])
  128.              esac
  129.             ])
  130.         else
  131.           # Some library is needed. Try libpthread and libc_r.
  132.           AC_CHECK_LIB(pthread, pthread_kill,
  133.             [gl_have_pthread=yes
  134.              LIBTHREAD=-lpthread LTLIBTHREAD=-lpthread
  135.              LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread])
  136.           if test -z "$gl_have_pthread"; then
  137.             # For FreeBSD 4.
  138.             AC_CHECK_LIB(c_r, pthread_kill,
  139.               [gl_have_pthread=yes
  140.                LIBTHREAD=-lc_r LTLIBTHREAD=-lc_r
  141.                LIBMULTITHREAD=-lc_r LTLIBMULTITHREAD=-lc_r])
  142.           fi
  143.         fi
  144.         if test -n "$gl_have_pthread"; then
  145.           gl_threads_api=posix
  146.           AC_DEFINE([USE_POSIX_THREADS], 1,
  147.             [Define if the POSIX multithreading library can be used.])
  148.           if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then
  149.             if test $gl_have_weak = yes; then
  150.               AC_DEFINE([USE_POSIX_THREADS_WEAK], 1,
  151.                 [Define if references to the POSIX multithreading library should be made weak.])
  152.               LIBTHREAD=
  153.               LTLIBTHREAD=
  154.             fi
  155.           fi
  156.           # OSF/1 4.0 and MacOS X 10.1 lack the pthread_rwlock_t type and the
  157.           # pthread_rwlock_* functions.
  158.           AC_CHECK_TYPE([pthread_rwlock_t],
  159.             [AC_DEFINE([HAVE_PTHREAD_RWLOCK], 1,
  160.                [Define if the POSIX multithreading library has read/write locks.])],
  161.             [],
  162.             [#include <pthread.h>])
  163.           # glibc defines PTHREAD_MUTEX_RECURSIVE as enum, not as a macro.
  164.           AC_TRY_COMPILE([#include <pthread.h>],
  165.             [#if __FreeBSD__ == 4
  166. error "No, in FreeBSD 4.0 recursive mutexes actually don't work."
  167. #else
  168. int x = (int)PTHREAD_MUTEX_RECURSIVE;
  169. return !x;
  170. #endif],
  171.             [AC_DEFINE([HAVE_PTHREAD_MUTEX_RECURSIVE], 1,
  172.                [Define if the <pthread.h> defines PTHREAD_MUTEX_RECURSIVE.])])
  173.         fi
  174.       fi
  175.     fi
  176.     if test -z "$gl_have_pthread"; then
  177.       if test "$gl_use_threads" = yes || test "$gl_use_threads" = solaris; then
  178.         gl_have_solaristhread=
  179.         gl_save_LIBS="$LIBS"
  180.         LIBS="$LIBS -lthread"
  181.         AC_TRY_LINK([#include <thread.h>
  182. #include <synch.h>],
  183.           [thr_self();],
  184.           [gl_have_solaristhread=yes])
  185.         LIBS="$gl_save_LIBS"
  186.         if test -n "$gl_have_solaristhread"; then
  187.           gl_threads_api=solaris
  188.           LIBTHREAD=-lthread
  189.           LTLIBTHREAD=-lthread
  190.           LIBMULTITHREAD="$LIBTHREAD"
  191.           LTLIBMULTITHREAD="$LTLIBTHREAD"
  192.           AC_DEFINE([USE_SOLARIS_THREADS], 1,
  193.             [Define if the old Solaris multithreading library can be used.])
  194.           if test $gl_have_weak = yes; then
  195.             AC_DEFINE([USE_SOLARIS_THREADS_WEAK], 1,
  196.               [Define if references to the old Solaris multithreading library should be made weak.])
  197.             LIBTHREAD=
  198.             LTLIBTHREAD=
  199.           fi
  200.         fi
  201.       fi
  202.     fi
  203.     if test "$gl_use_threads" = pth; then
  204.       gl_save_CPPFLAGS="$CPPFLAGS"
  205.       AC_LIB_LINKFLAGS(pth)
  206.       gl_have_pth=
  207.       gl_save_LIBS="$LIBS"
  208.       LIBS="$LIBS -lpth"
  209.       AC_TRY_LINK([#include <pth.h>], [pth_self();], gl_have_pth=yes)
  210.       LIBS="$gl_save_LIBS"
  211.       if test -n "$gl_have_pth"; then
  212.         gl_threads_api=pth
  213.         LIBTHREAD="$LIBPTH"
  214.         LTLIBTHREAD="$LTLIBPTH"
  215.         LIBMULTITHREAD="$LIBTHREAD"
  216.         LTLIBMULTITHREAD="$LTLIBTHREAD"
  217.         AC_DEFINE([USE_PTH_THREADS], 1,
  218.           [Define if the GNU Pth multithreading library can be used.])
  219.         if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then
  220.           if test $gl_have_weak = yes; then
  221.             AC_DEFINE([USE_PTH_THREADS_WEAK], 1,
  222.               [Define if references to the GNU Pth multithreading library should be made weak.])
  223.             LIBTHREAD=
  224.             LTLIBTHREAD=
  225.           fi
  226.         fi
  227.       else
  228.         CPPFLAGS="$gl_save_CPPFLAGS"
  229.       fi
  230.     fi
  231.     if test -z "$gl_have_pthread"; then
  232.       if test "$gl_use_threads" = yes || test "$gl_use_threads" = win32; then
  233.         if { case "$host_os" in
  234.                mingw*) true;;
  235.                *) false;;
  236.              esac
  237.            }; then
  238.           gl_threads_api=win32
  239.           AC_DEFINE([USE_WIN32_THREADS], 1,
  240.             [Define if the Win32 multithreading API can be used.])
  241.         fi
  242.       fi
  243.     fi
  244.   fi
  245.   AC_MSG_CHECKING([for multithread API to use])
  246.   AC_MSG_RESULT([$gl_threads_api])
  247.   AC_SUBST(LIBTHREAD)
  248.   AC_SUBST(LTLIBTHREAD)
  249.   AC_SUBST(LIBMULTITHREAD)
  250.   AC_SUBST(LTLIBMULTITHREAD)
  251. ])
  252.  
  253. AC_DEFUN([gl_LOCK],
  254. [
  255.   AC_REQUIRE([gl_LOCK_EARLY])
  256.   AC_REQUIRE([gl_LOCK_BODY])
  257.   gl_PREREQ_LOCK
  258. ])
  259.  
  260. # Prerequisites of lib/lock.c.
  261. AC_DEFUN([gl_PREREQ_LOCK], [
  262.   AC_REQUIRE([AC_C_INLINE])
  263. ])
  264.  
  265. dnl Survey of platforms:
  266. dnl
  267. dnl Platform          Available   Compiler    Supports   test-lock
  268. dnl                   flavours    option      weak       result
  269. dnl ---------------   ---------   ---------   --------   ---------
  270. dnl Linux 2.4/glibc   posix       -lpthread       Y      OK
  271. dnl
  272. dnl GNU Hurd/glibc    posix
  273. dnl
  274. dnl FreeBSD 5.3       posix       -lc_r           Y
  275. dnl                   posix       -lkse ?         Y
  276. dnl                   posix       -lpthread ?     Y
  277. dnl                   posix       -lthr           Y
  278. dnl
  279. dnl FreeBSD 5.2       posix       -lc_r           Y
  280. dnl                   posix       -lkse           Y
  281. dnl                   posix       -lthr           Y
  282. dnl
  283. dnl FreeBSD 4.0,4.10  posix       -lc_r           Y      OK
  284. dnl
  285. dnl NetBSD 1.6        --
  286. dnl
  287. dnl OpenBSD 3.4       posix       -lpthread       Y      OK
  288. dnl
  289. dnl MacOS X 10.[123]  posix       -lpthread       Y      OK
  290. dnl
  291. dnl Solaris 7,8,9     posix       -lpthread       Y      Sol 7,8: 0.0; Sol 9: OK
  292. dnl                   solaris     -lthread        Y      Sol 7,8: 0.0; Sol 9: OK
  293. dnl
  294. dnl HP-UX 11          posix       -lpthread       N (cc) OK
  295. dnl                                               Y (gcc)
  296. dnl
  297. dnl IRIX 6.5          posix       -lpthread       Y      0.5
  298. dnl
  299. dnl AIX 4.3,5.1       posix       -lpthread       N      AIX 4: 0.5; AIX 5: OK
  300. dnl
  301. dnl OSF/1 4.0,5.1     posix       -pthread (cc)   N      OK
  302. dnl                               -lpthread (gcc) Y
  303. dnl
  304. dnl Cygwin            posix       -lpthread       Y      OK
  305. dnl
  306. dnl Any of the above  pth         -lpth                  0.0
  307. dnl
  308. dnl Mingw             win32                       N      OK
  309. dnl
  310. dnl BeOS 5            --
  311. dnl
  312. dnl The test-lock result shows what happens if in test-lock.c EXPLICIT_YIELD is
  313. dnl turned off:
  314. dnl   OK if all three tests terminate OK,
  315. dnl   0.5 if the first test terminates OK but the second one loops endlessly,
  316. dnl   0.0 if the first test already loops endlessly.
  317.